Taming Macros

Scheme includes a simple yet powerful macro mechanism. Using macros, programmers can easily extend the language with new kinds of expressions and definitions, thus abstracting over recurring syntactic patterns. As with every other powerful language mechanism, programmers can also easily misuse macros and, to this day, broken macro definitions or macro uses pose complex debugging problems to programmers at all levels of experience. In this paper, we present a type system for taming Scheme-like macros. Specifically, we formulate a small model that captures the essential properties of Scheme-style macros. For this model, we formulate a novel type system to eliminate some of these problems, prove its soundness, and validate its pragmatic usefulness. 1 The Power of Macro Programming Over the past 20 years, the Scheme community has developed an expressive and easy-to-use standard macro system [1]. To introduce a new construct via a macro, a programmer simply writes down a rewriting rule consisting of a pair of syntactic patterns [2]. The left-hand side is called a pattern; the right-hand side is referred to as a template. Collectively the set of rules specifies how the macro expander must translate the surface syntax into core syntax. The macro expander eliminates each instance of the pattern in the program by replacing it with an instance of the template where all pattern variables have been appropriately substituted. Scheme implementors often use the macro system to equip the language with additional forms of expressions. Programmers use the macro system for similar reasons. Many define small domain-specific notations and then formulate their program in a mix of Scheme and domain-specific expressions [3, 4]. The macro system thus empowers them to follow the old Lisp maxim on problem-solving via language definition, which says that programmers should formulate an embedded programming language for the problem domain and that they should express their solution for the domain in this new language. Naturally, every powerful programming construct invites misuse. For example, a programmer may pass the wrong number of arguments to a function or attempt to apply an operation on the wrong kind of value (such as destructuring a number as if it were a pair or dividing by zero). These errors may cause incorrect program results or run-time exceptions. A programmer may misuse macros in similar ways. Misuse of macros may cause the generation of an incorrect program or the triggering of errors during compilation. Given the weak programming environments for macro expansion, debugging macro misuses is extremely difficult compared to other constructs. With this paper, we attempt to reconcile type checking with powerful syntactic abstractions in the spirit of Scheme. Naturally, the type system reduces the power of the macro system, but we believe that it retains enough for Scheme programmers with ordinary problems. We discuss the one exception to this claim in the conclusion. In the meantime, we briefly introduce macros; illustrate potential misuses; and present our unusual type system and a model for macro expansion so that we can prove type soundness. The penultimate section shows how we can extend our model to accommodate most of Scheme’s expressive powers. Finally, we discuss related and future work toward taming macros. Note: A preliminary version of this paper appeared in the Scheme and Functional Programming Workshop 2003 [5].